home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / nos042_s / domain.c < prev    next >
C/C++ Source or Header  |  1994-09-16  |  60KB  |  2,538 lines
  1.  /*
  2.  *      DOMAIN.C -- domain name system stub resolver
  3.  *
  4.  *      Original code by Phil Karn, KA9Q.
  5.  *
  6.  *      Apr 90  Bill Simpson added address->name resolution, time-to-live,
  7.  *      thru    memory caching, generalized multi-record multi-type searches,
  8.  *      Oct 90  and many minor changes to conform more closely to the RFCs.
  9.  *      Feb 91  Bill Simpson added "query" command and TYPE_ANY processing.
  10.  *      Jul 91  Bill Simpson added "more" sessions for query and cache list.
  11.  *
  12.  *      ATARI Version by David Nash - dnash@chaos.demon.co.uk
  13.  */
  14.  
  15. /****************************************************************************
  16. *       $Id: domain.c 1.5 94/01/04 14:09:08 ROOT_DOS Exp $
  17.  
  18. *  07 Jun 92    1.2    GT Reset DNS timeout on DNS failure.
  19. *        Oct 92     -   mt@kram.demon.co.uk (G7LEU) merged NOS WG7J104 DNS code.
  20. *        Feb 93     -   lonewolf@sphere.demon.co.uk fixed DNS reply to TYPE_ANY
  21. *                            query.  Added domain qtype <n> to set the query type used
  22. *                        by domain query. Useful if your server doesn't understand
  23. *                     TYPE_ANY changed all remaining printf to tprintf.
  24. *    17 May 93    1.4    GT    Fix warnings.    
  25. *    24 Dec 93    1.5    GT    Fix conditionals.
  26. ****************************************************************************/
  27.  
  28. #include <stdio.h>
  29. #include <ctype.h>
  30. #include <time.h>
  31. #ifdef ATARI
  32. #include <sys/types.h>
  33. #endif
  34. #include <sys/stat.h>
  35. #ifndef ATARI
  36. #include <dir.h>
  37. #else
  38. #include <sys/dir.h>
  39. #endif
  40. #include <dos.h>
  41. #include <string.h>
  42. #include <stdarg.h>
  43. #include "global.h"
  44. #include "config.h"
  45. #include "mbuf.h"
  46. #include "proc.h"
  47. #include "ip.h"
  48. #include "netuser.h"
  49. #include "session.h"
  50. #include "socket.h"
  51. #include "cmdparse.h"
  52. #include "commands.h"
  53. #include "files.h"
  54. #include "main.h"
  55. #include "domain.h"
  56.  
  57. #undef  DEBUG                           /* for certain trace messages */
  58. #undef  DEBUG_PAIN                      /* for painful debugging */
  59.  
  60. static struct rr *Dcache = NULLRR;      /* Cache of resource records */
  61. static int Dcache_size = 20;            /* size limit */
  62. static time_t Dcache_time = 0L;         /* timestamp */
  63.  
  64. static int Dfile_clean = FALSE;         /* discard expired records (flag) */
  65. static int Dfile_reading = 0;           /* read interlock (count) */
  66. static int Dfile_writing = 0;           /* write interlock (count) */
  67.  
  68. struct proc *Dfile_updater = NULLPROC;
  69. static int32 Dfile_wait_absolute = 0L;  /* timeout Clock time */
  70. static int Dfile_wait_relative = 300;   /* timeout file activity (seconds) */
  71.  
  72. static struct dserver *Dservers = NULLDOM; /* List of potential servers */
  73. static int Dserver_retries = 2;         /* Attempts to reach servers */
  74. static int32 Dserver_maxwait = 0L;      /* maximum server timeout limit (seconds) */
  75.  
  76. static char *Dsuffix = NULLCHAR;        /* Default suffix for names without periods */
  77. static int Dtrace = FALSE;
  78. static int qtype = 255;
  79.  
  80. static char *Dtypes[] = {
  81.     "",
  82.     "A",
  83.     "NS",
  84.     "MD",
  85.     "MF",
  86.     "CNAME",
  87.     "SOA",
  88.     "MB",
  89.     "MG",
  90.     "MR",
  91.     "NULL",
  92.     "WKS",
  93.     "PTR",
  94.     "HINFO",
  95.     "MINFO",
  96.     "MX",
  97.     "TXT"
  98. };
  99. static int Ndtypes = 17;
  100. static char delim[] = " \t\r\n";
  101.  
  102. #ifdef DSERVER
  103. static struct DOM_FILE {
  104.     struct DOM_FILE *next;
  105.     char type;
  106.     char *filename;
  107.     char *domain;
  108.     int32 source;
  109.     struct soa dom_soa;
  110.     } *dom_file = NULL;
  111. struct proc *Drx;
  112. int Dsocket;
  113. extern char *Dzones;
  114. extern char *Dboot;
  115. #endif
  116.  
  117. extern int are_we_an_mx;
  118.  
  119. static int docache __ARGS((int argc,char *argv[],void *p));
  120. static int dosuffix __ARGS((int argc,char *argv[],void *p));
  121.  
  122. static int docacheclean __ARGS((int argc,char *argv[],void *p));
  123. static int __stdargs docachelist __ARGS((int argc,char *argv[],void *p));
  124. static int docachesize __ARGS((int argc,char *argv[],void *p));
  125. static int docachewait __ARGS((int argc,char *argv[],void *p));
  126.  
  127. static void dlist_add __ARGS((struct dserver *dp));
  128. static void dlist_drop __ARGS((struct dserver *dp));
  129. static int dodnsadd __ARGS((int argc,char *argv[],void *p));
  130. static int dodnsdrop __ARGS((int argc,char *argv[],void *p));
  131. static int dodnslist __ARGS((int argc,char *argv[],void *p));
  132. static int dodnsmaxw __ARGS((int argc,char *argv[],void *p));
  133. static int __stdargs dodnsquery __ARGS((int argc,char *argv[],void *p));
  134. static int dodnsretry __ARGS((int argc,char *argv[],void *p));
  135. static int dodnstrace __ARGS((int argc,char *argv[],void *p));
  136. static int __stdargs doqtype __ARGS((int argc,char *argv[],void *p));
  137.  
  138. static char * dtype __ARGS((int value));
  139. static int check_ttl __ARGS((struct rr *rrlp));
  140. static int compare_rr __ARGS((struct rr *search_rrp,struct rr *target_rrp));
  141. static int compare_rr_list __ARGS((struct rr *rrlp,struct rr *target_rrp));
  142. static struct rr *copy_rr __ARGS((struct rr *rrp));
  143. static struct rr *copy_rr_list __ARGS((struct rr *rrlp));
  144. static struct rr *make_rr __ARGS((int source, char *dname,int16 class,int16 type,int32 ttl,int16 rdl,void *data));
  145.  
  146. static void dcache_add __ARGS((struct rr *rrlp));
  147. static void dcache_drop __ARGS((struct rr *rrp));
  148. static struct rr *dcache_search __ARGS((struct rr *rrlp));
  149. static void dcache_update __ARGS((struct rr *rrlp));
  150.  
  151. static struct rr *get_rr __ARGS((FILE *fp, struct rr *lastrrp));
  152. static void put_rr __ARGS((FILE *fp,struct rr *rrp));
  153. static struct rr *dfile_search __ARGS((struct rr *rrlp, char *filename));
  154. static void __stdargs dfile_update __ARGS((int s,void *unused,void *p));
  155.  
  156. static void dumpdomain __ARGS((struct dhdr *dhp,int32 rtt));
  157. static int dns_makequery __ARGS((int16 op,struct rr *rrp, char *buffer,int16 buflen));
  158. static void dns_query __ARGS((struct rr *rrlp));
  159.  
  160. static int isaddr __ARGS((char *s));
  161. static char *checksuffix __ARGS((char *dname));
  162. static struct rr *resolver __ARGS((struct rr *rrlp));
  163.  
  164. #ifdef DSERVER
  165. static void free_dhdr __ARGS((struct dhdr *));
  166. static void __stdargs proc_query __ARGS((int,void *,void *));
  167. static void __stdargs drx __ARGS((int,void *,void *));
  168. static int dodnsserver __ARGS((int argc,char *argv[],void *p));
  169. static int dostopdnsserver __ARGS((int argc,char *argv[],void *p));
  170. #endif
  171.  
  172. /**
  173.  **     Domain Resolver Commands
  174.  **/
  175.  
  176. static struct cmds Dcmds[] = {
  177.     { "addserver",    dodnsadd,       0, 2, "add <hostid>" },
  178.     { "dropserver",   dodnsdrop,      0, 2, "drop <hostid>" },
  179.     { "list",         dodnslist,      0, 0, NULLCHAR },
  180.     { "maxwait",      dodnsmaxw,      0, 0, NULLCHAR },
  181.     { "query",        dodnsquery,   512, 2, "query <hostid>" },
  182.     { "qtype",        doqtype,        0, 0, NULLCHAR },
  183.     { "retry",        dodnsretry,     0, 0, NULLCHAR },
  184.     { "suffix",       dosuffix,       0, 0, NULLCHAR },
  185. #ifdef DSERVER
  186.     { "startdns", dodnsserver,0, 0, NULLCHAR },
  187.     { "stopdns", dostopdnsserver,0, 0, NULLCHAR },
  188. #endif
  189.     { "trace",        dodnstrace,     0, 0, NULLCHAR },
  190.     { "cache",        docache,        0, 0, NULLCHAR },
  191.     { NULLCHAR },
  192. };
  193.  
  194. static struct cmds Dcachecmds[] = {
  195.     { "clean",        docacheclean,   0, 0, NULLCHAR },
  196.     { "list",         docachelist,  512, 0, NULLCHAR },
  197.     { "size",         docachesize,    0, 0, NULLCHAR },
  198.     { "wait",         docachewait,    0, 0, NULLCHAR },
  199.     { NULLCHAR },
  200. };
  201.  
  202. int
  203. dodomain(argc,argv,p)
  204. int argc;
  205. char *argv[];
  206. void *p;
  207. {
  208.     return subcmd(Dcmds,argc,argv,p);
  209. }
  210.  
  211. static int
  212. docache(argc,argv,p)
  213. int argc;
  214. char *argv[];
  215. void *p;
  216. {
  217.     return subcmd(Dcachecmds,argc,argv,p);
  218. }
  219.  
  220. static int
  221. dosuffix(argc,argv,p)
  222. int argc;
  223. char *argv[];
  224. void *p;
  225. {
  226.     if(argc < 2){
  227.         if(Dsuffix != NULLCHAR)
  228.             tprintf("%s\n",Dsuffix);
  229.         return 0;
  230.     }
  231.     free(Dsuffix);
  232.     Dsuffix = strdup(argv[1]);
  233.     return 0;
  234. }
  235.  
  236. static
  237. dodnsmaxw(argc,argv,p)
  238. int argc;
  239. char *argv[];
  240. void *p;
  241. {
  242.     return setlong(&Dserver_maxwait,"Server response timeout limit (sec)",argc,argv);
  243. }
  244.  
  245. static int
  246. docacheclean(argc,argv,p)
  247. int argc;
  248. char *argv[];
  249. void *p;
  250. {
  251.     return setbool( &Dfile_clean, "discard expired records", argc,argv );
  252. }
  253.  
  254. static int __stdargs
  255. docachelist(argc,argv,p)
  256. int argc;
  257. char *argv[];
  258. void *p;
  259. {
  260.     struct rr *rrp;
  261.     struct session *sp;
  262.     int row = MOREROWS;
  263.  
  264.     if((sp = newsession(argv[1],DCLIST)) == NULLSESSION){
  265.         return -1;
  266.     }
  267.  
  268.     (void)dcache_search(NULLRR); /* update ttl */
  269.  
  270.     /* Put tty into raw mode so single-char responses will work */
  271.     sp->ttystate.echo = sp->ttystate.edit = 0;
  272.  
  273.     for(rrp=Dcache;rrp!=NULLRR;rrp=rrp->next)
  274.     {
  275.         put_rr(stdout,rrp);
  276.         if(--row == 0){
  277.             row = keywait("--More--",0);
  278.             switch(row){
  279.             case -1:
  280.             case 'q':
  281.             case 'Q':
  282.                 rrp = NULLRR;
  283.                 break;
  284.             case '\n':
  285.             case '\r':
  286.                 row = 1;
  287.                 break;
  288.             case ' ':
  289.             default:
  290.                 row = MOREROWS;
  291.             };
  292.         }
  293.     }
  294.     fflush(stdout);
  295.     keywait(NULLCHAR,1);
  296.     freesession(sp);
  297.     return 0;
  298. }
  299.  
  300. static int
  301. docachesize(argc,argv,p)
  302. int argc;
  303. char *argv[];
  304. void *p;
  305. {
  306.     int newsize;
  307.     int oldsize;
  308.     int result;
  309.  
  310.     newsize = oldsize = Dcache_size;
  311.     result = setint( &newsize, "memory cache size", argc,argv );
  312.  
  313.     if(newsize > 0){
  314.         Dcache_size = newsize;
  315.         if(newsize < oldsize){
  316.             (void)dcache_search(NULLRR); /* update size */
  317.         }
  318.     }
  319.     return result;
  320. }
  321.  
  322. static int
  323. docachewait(argc,argv,p)
  324. int argc;
  325. char *argv[];
  326. void *p;
  327. {
  328.     return setint( &Dfile_wait_relative, "time before file update (seconds)", argc,argv );
  329. }
  330.  
  331. static void
  332. dlist_add(dp)
  333. register struct dserver *dp;
  334. {
  335.     dp->prev = NULLDOM;
  336.     dp->next = Dservers;
  337.     if(Dservers != NULLDOM)
  338.         Dservers->prev = dp;
  339.     Dservers = dp;
  340. }
  341.  
  342. static void
  343. dlist_drop(dp)
  344. register struct dserver *dp;
  345. {
  346.     if(dp->prev != NULLDOM)
  347.         dp->prev->next = dp->next;
  348.     else
  349.         Dservers = dp->next;
  350.     if(dp->next != NULLDOM)
  351.         dp->next->prev = dp->prev;
  352. }
  353.  
  354. static int
  355. dodnsadd(argc,argv,p)
  356. int argc;
  357. char *argv[];
  358. void *p;
  359. {
  360.     int32 address;
  361.  
  362.     if((address = resolve(argv[1])) == 0L){
  363.         tprintf("Resolver %s unknown\n",argv[1]);
  364.         return 1;
  365.     }
  366.     return add_nameserver(address);
  367. }
  368. int
  369. add_nameserver(address)
  370. int32 address;
  371. {
  372.     struct dserver *dp;
  373.  
  374.     dp = (struct dserver *)callocw(1,sizeof(struct dserver));
  375.     dp->address = address;
  376.     dp->srtt = 5000L; /* 5 sec */
  377.     dp->mdev = 0;
  378.     dp->timeout = 2 * dp->mdev + dp->srtt + 3;
  379.     dlist_add(dp);
  380.     return 0;
  381. }
  382.  
  383. static int
  384. dodnsdrop(argc,argv,p)
  385. int argc;
  386. char *argv[];
  387. void *p;
  388. {
  389.     struct dserver *dp;
  390.     int32 addr;
  391.  
  392.     addr = resolve(argv[1]);
  393.     for(dp = Dservers;dp != NULLDOM;dp = dp->next)
  394.         if(addr == dp->address)
  395.             break;
  396.  
  397.     if(dp == NULLDOM){
  398.         tprintf("Not found\n");
  399.         return 1;
  400.     }
  401.  
  402.     dlist_drop(dp);
  403.     free((char *)dp);
  404.     return 0;
  405. }
  406.  
  407. static int
  408. dodnslist(argc,argv,p)
  409. int argc;
  410. char *argv[];
  411. void *p;
  412. {
  413. #ifdef DSERVER
  414.     struct DOM_FILE *t_dom_file;
  415. #endif
  416.     register struct dserver *dp;
  417.  
  418.     tprintf("Server address          srtt    mdev    timeout  queries responses timeouts\n");
  419.     for(dp = Dservers;dp != NULLDOM;dp = dp->next){
  420.         tprintf("%-20s%8lu%8lu%10lu%10lu%10lu%10lu\n",
  421.          inet_ntoa(dp->address),
  422.          dp->srtt,dp->mdev,dp->timeout,
  423.          dp->queries,dp->responses,dp->timeouts);
  424.     }
  425. #ifdef DSERVER
  426.     if (Drx == NULLPROC)
  427.         tprintf("Domain Name Server not running.\n");
  428.     else tprintf("Domain Name Server running.\n");
  429.     t_dom_file = dom_file;
  430.     while(Drx != NULLPROC && t_dom_file)
  431.         {
  432.         if (t_dom_file->type == '1')
  433.             tprintf("We are primary for %s\n", t_dom_file->domain);
  434.         else if (t_dom_file->type == '2')
  435.             tprintf("We are secondary for %s (from %s)\n",
  436.                             t_dom_file->domain, inet_ntoa(t_dom_file->source));
  437.         t_dom_file = t_dom_file->next;
  438.         }
  439. #endif
  440.     return 0;
  441. }
  442.  
  443. static int __stdargs
  444. doqtype(argc,argv,p)
  445. int argc;
  446. char *argv[];
  447. void *p;
  448. {
  449.     return setint(&qtype,"Query type",argc,argv);
  450. }
  451.  
  452. static int __stdargs
  453. dodnsquery(argc,argv,p)
  454. int argc;
  455. char *argv[];
  456. void *p;
  457. {
  458.     struct rr *rrp;
  459.     struct rr *result_rrlp;
  460.     char *sname;
  461.     struct session *sp;
  462.     int row = MOREROWS;
  463.  
  464.     if((sp = newsession(argv[1],DQUERY)) == NULLSESSION){
  465.         return -1;
  466.     }
  467.  
  468.     if ( isaddr( argv[1] ) ) {
  469.         result_rrlp = inverse_a( aton( argv[1] ) );
  470.     } else {
  471.         sname = checksuffix( argv[1] );
  472.         rrp = make_rr(RR_QUERY,sname,CLASS_IN,qtype,0,0,NULL);
  473.         free(sname);
  474.  
  475.         dns_query(rrp);
  476.         result_rrlp = dcache_search(rrp);
  477.         free_rr(rrp);
  478.     }
  479.  
  480.     /* Put tty into raw mode so single-char responses will work */
  481.     sp->ttystate.echo = sp->ttystate.edit = 0;
  482.  
  483.     for( rrp=result_rrlp; rrp!=NULLRR; rrp=rrp->next)
  484.     {
  485.         put_rr(stdout,rrp);
  486.         if(--row == 0){
  487.             row = keywait("--More--",0);
  488.             switch(row){
  489.             case -1:
  490.             case 'q':
  491.             case 'Q':
  492.                 rrp = NULLRR;
  493.                 break;
  494.             case '\n':
  495.             case '\r':
  496.                 row = 1;
  497.                 break;
  498.             case ' ':
  499.             default:
  500.                 row = MOREROWS;
  501.             };
  502.         }
  503.     }
  504.     fflush(stdout);
  505.     free_rr(result_rrlp);
  506.     keywait(NULLCHAR,1);
  507.     freesession(sp);
  508.     return 0;
  509. }
  510.  
  511. static int
  512. dodnsretry(argc,argv,p)
  513. int argc;
  514. char *argv[];
  515. void *p;
  516. {
  517.     return setint( &Dserver_retries, "server retries", argc,argv );
  518. }
  519.  
  520. static int
  521. dodnstrace(argc,argv,p)
  522. int argc;
  523. char *argv[];
  524. void *p;
  525. {
  526.     return setbool(&Dtrace,"server trace",argc,argv);
  527. }
  528.  
  529.  
  530. /**
  531.  **     Domain Resource Record Utilities
  532.  **/
  533.  
  534. static char *
  535. dtype(value)
  536. int value;
  537. {
  538.     static char buf[10];
  539.  
  540.     if (value < Ndtypes)
  541.         return Dtypes[value];
  542.  
  543.     sprintf( buf, "{%d}", value);
  544.     return buf;
  545. }
  546.  
  547. /* check list of resource records for any expired ones.
  548.  * returns number of expired records.
  549.  */
  550. static int
  551. check_ttl(rrlp)
  552. register struct rr *rrlp;
  553. {
  554.     int count = 0;
  555.  
  556.     while(rrlp != NULLRR){
  557.         if(rrlp->ttl == 0L)
  558.             count++;
  559.         rrlp = rrlp->next;
  560.     }
  561.     return count;
  562. }
  563.  
  564. /* Compare two resource records.
  565.  * returns 0 if match, nonzero otherwise.
  566.  */
  567. static int
  568. compare_rr(search_rrp,target_rrp)
  569. register struct rr *search_rrp,*target_rrp;
  570. {
  571.     int i;
  572.  
  573.     if(search_rrp == NULLRR || target_rrp == NULLRR)
  574.         return -32765;
  575.  
  576.     if(search_rrp->class != target_rrp->class)
  577.         return -32763;
  578.  
  579.     if(search_rrp->type != TYPE_ANY
  580.     && search_rrp->type != target_rrp->type
  581.     && (search_rrp->source != RR_QUERY
  582.      || (target_rrp->type != TYPE_CNAME
  583.       && target_rrp->type != TYPE_PTR)))
  584.         return -32761;
  585.  
  586.     if(search_rrp->source != RR_INQUERY){
  587. /*
  588.         if((i = strlen(search_rrp->name)) != strlen(target_rrp->name))
  589.             return -32759;
  590. */
  591.         i = strlen(target_rrp->name);
  592.         if((i = strnicmp(search_rrp->name,target_rrp->name,i)) != 0)
  593.             return i;
  594.  
  595.         /* match negative records so that they are replaced */
  596.         if(target_rrp->rdlength == 0)
  597.             return 0;
  598.     }
  599.  
  600.     /* if a query has gotten this far, match it */
  601.     if(search_rrp->source == RR_QUERY)
  602.         return 0;
  603.  
  604.     /* ensure negative records don't replace older records */
  605.     if(search_rrp->rdlength == 0)
  606.         return -32757;
  607.  
  608.     /* match expired records so that they are replaced */
  609.     if(search_rrp->source != RR_INQUERY){
  610.         if(target_rrp->ttl == 0L)
  611.             return 0;
  612.     }
  613.  
  614.     /* Note: rdlengths are not compared because they vary depending
  615.      * on the representation (ASCII or encoded) this record was
  616.      * generated from.
  617.      */
  618.  
  619.     switch(search_rrp->type){
  620.     case TYPE_A:
  621.         i = search_rrp->rdata.addr != target_rrp->rdata.addr;
  622.         break;
  623.     case TYPE_CNAME:
  624.     case TYPE_MB:
  625.     case TYPE_MG:
  626.     case TYPE_MR:
  627.     case TYPE_NS:
  628.     case TYPE_PTR:
  629.     case TYPE_TXT:
  630.         i = stricmp(search_rrp->rdata.data,target_rrp->rdata.data);
  631.         break;
  632.     case TYPE_HINFO:
  633.         i = strcmp(search_rrp->rdata.hinfo.cpu,target_rrp->rdata.hinfo.cpu) ||
  634.             strcmp(search_rrp->rdata.hinfo.os,target_rrp->rdata.hinfo.os);
  635.         break;
  636.     case TYPE_MX:
  637.         i = stricmp(search_rrp->rdata.mx.exch,target_rrp->rdata.mx.exch);
  638.         break;
  639.     case TYPE_SOA:
  640.         i = search_rrp->rdata.soa.serial != target_rrp->rdata.soa.serial;
  641.         break;
  642.     default:
  643.         i = -32755;     /* unsupported */
  644.     }
  645.     return i;
  646. }
  647.  
  648. static int
  649. compare_rr_list(rrlp,target_rrp)
  650. register struct rr *rrlp,*target_rrp;
  651. {
  652.     while(rrlp != NULLRR){
  653.         if(compare_rr(rrlp,target_rrp) == 0)
  654.             return 0;
  655. #ifdef DEBUG_PAIN
  656.         if(Dtrace)
  657.             tprintf("%15d %s\n",
  658.                 compare_rr(rrlp,target_rrp),
  659.                 target_rrp->name);
  660. #endif
  661.         rrlp = rrlp->next;
  662.     }
  663.     return -32767;
  664. }
  665.  
  666. /* Make a new copy of a resource record */
  667. static struct rr *
  668. copy_rr(rrp)
  669. register struct rr *rrp;
  670. {
  671.     register struct rr *newrr;
  672.  
  673.     if(rrp == NULLRR)
  674.         return NULLRR;
  675.  
  676.     newrr = (struct rr *)callocw(1,sizeof(struct rr));
  677.     newrr->source = rrp->source;
  678.     newrr->name =   strdup(rrp->name);
  679.     newrr->type =   rrp->type;
  680.     newrr->class =  rrp->class;
  681.     newrr->ttl =    rrp->ttl;
  682.     if((newrr->rdlength = rrp->rdlength) == 0)
  683.         return newrr;
  684.  
  685.     switch(rrp->type){
  686.     case TYPE_A:
  687.         newrr->rdata.addr = rrp->rdata.addr;
  688.         break;
  689.     case TYPE_CNAME:
  690.     case TYPE_MB:
  691.     case TYPE_MG:
  692.     case TYPE_MR:
  693.     case TYPE_NS:
  694.     case TYPE_PTR:
  695.     case TYPE_TXT:
  696.         newrr->rdata.name = strdup(rrp->rdata.name);
  697.         break;
  698.     case TYPE_HINFO:
  699.         newrr->rdata.hinfo.cpu = strdup(rrp->rdata.hinfo.cpu);
  700.         newrr->rdata.hinfo.os = strdup(rrp->rdata.hinfo.os);
  701.         break;
  702.     case TYPE_MX:
  703.         newrr->rdata.mx.pref = rrp->rdata.mx.pref;
  704.         newrr->rdata.mx.exch = strdup(rrp->rdata.mx.exch);
  705.         break;
  706.     case TYPE_SOA:
  707.         newrr->rdata.soa.mname =        strdup(rrp->rdata.soa.mname);
  708.         newrr->rdata.soa.rname =        strdup(rrp->rdata.soa.rname);
  709.         newrr->rdata.soa.serial =       rrp->rdata.soa.serial;
  710.         newrr->rdata.soa.refresh =      rrp->rdata.soa.refresh;
  711.         newrr->rdata.soa.retry =        rrp->rdata.soa.retry;
  712.         newrr->rdata.soa.expire =       rrp->rdata.soa.expire;
  713.         newrr->rdata.soa.minimum =      rrp->rdata.soa.minimum;
  714.         break;
  715.     }
  716.     return newrr;
  717. }
  718.  
  719. static struct rr *
  720. copy_rr_list(rrlp)
  721. register struct rr *rrlp;
  722. {
  723.     register struct rr **rrpp;
  724.     struct rr *result_rrlp;
  725.  
  726. #ifdef ATARI
  727. #pragma ignore 94     /* ignore uninitialised auto warninge for rrlp */
  728. #endif
  729.  
  730.     rrpp = &result_rrlp;
  731.     while(rrlp != NULLRR){
  732.         *rrpp = copy_rr(rrlp);
  733.         rrpp = &(*rrpp)->next;
  734.         rrlp = rrlp->next;
  735.     }
  736.     *rrpp = NULLRR;
  737.     return result_rrlp;
  738. }
  739.  
  740. /* Free (list of) resource records */
  741. void
  742. free_rr(rrlp)
  743. register struct rr *rrlp;
  744. {
  745.     register struct rr *rrp;
  746.  
  747.     while((rrp = rrlp) != NULLRR){
  748.         rrlp = rrlp->next;
  749.  
  750.         free(rrp->comment);
  751.         free(rrp->name);
  752.         if(rrp->rdlength > 0){
  753.             switch(rrp->type){
  754.             case TYPE_A:
  755.                 break;  /* Nothing allocated in rdata section */
  756.             case TYPE_CNAME:
  757.             case TYPE_MB:
  758.             case TYPE_MG:
  759.             case TYPE_MR:
  760.             case TYPE_NS:
  761.             case TYPE_PTR:
  762.             case TYPE_TXT:
  763.                 free(rrp->rdata.name);
  764.                 break;
  765.             case TYPE_HINFO:
  766.                 free(rrp->rdata.hinfo.cpu);
  767.                 free(rrp->rdata.hinfo.os);
  768.                 break;
  769.             case TYPE_MX:
  770.                 free(rrp->rdata.mx.exch);
  771.                 break;
  772.             case TYPE_SOA:
  773.                 free(rrp->rdata.soa.mname);
  774.                 free(rrp->rdata.soa.rname);
  775.                 break;
  776.             }
  777.         }
  778.         free((char *)rrp);
  779.     }
  780. }
  781.  
  782. static struct rr *
  783. make_rr(
  784.     int source,
  785.     char *dname,
  786.     int16 dclass,
  787.     int16 dtype,
  788.     int32 ttl,
  789.     int16 rdl,
  790.     void *data)
  791. {
  792.     register struct rr *newrr;
  793.  
  794.     newrr = (struct rr *)callocw(1,sizeof(struct rr));
  795.     newrr->source = source;
  796.     newrr->name = strdup(dname);
  797.     newrr->class = dclass;
  798.     newrr->type = dtype;
  799.     newrr->ttl = ttl;
  800.     if((newrr->rdlength = rdl) == 0)
  801.         return newrr;
  802.  
  803.     switch(dtype){
  804.     case TYPE_A:
  805.       {
  806.         register int32 *ap = (int32 *)data;
  807.         newrr->rdata.addr = *ap;
  808.         break;
  809.       }
  810.     case TYPE_CNAME:
  811.     case TYPE_MB:
  812.     case TYPE_MG:
  813.     case TYPE_MR:
  814.     case TYPE_NS:
  815.     case TYPE_PTR:
  816.     case TYPE_TXT:
  817.     case TYPE_AXFR: /*##*/
  818.       {
  819.         newrr->rdata.name = strdup((char *)data);
  820.         break;
  821.       }
  822.     case TYPE_HINFO:
  823.       {
  824.         register struct hinfo *hinfop = (struct hinfo *)data;
  825.         newrr->rdata.hinfo.cpu = strdup(hinfop->cpu);
  826.         newrr->rdata.hinfo.os = strdup(hinfop->os);
  827.         break;
  828.       }
  829.     case TYPE_MX:
  830.       {
  831.         register struct mx *mxp = (struct mx *)data;
  832.         newrr->rdata.mx.pref = mxp->pref;
  833.         newrr->rdata.mx.exch = strdup(mxp->exch);
  834.         break;
  835.       }
  836.     case TYPE_SOA:
  837.       {
  838.         register struct soa *soap = (struct soa *)data;
  839.         newrr->rdata.soa.mname =        strdup(soap->mname);
  840.         newrr->rdata.soa.rname =        strdup(soap->rname);
  841.         newrr->rdata.soa.serial =       soap->serial;
  842.         newrr->rdata.soa.refresh =      soap->refresh;
  843.         newrr->rdata.soa.retry =        soap->retry;
  844.         newrr->rdata.soa.expire =       soap->expire;
  845.         newrr->rdata.soa.minimum =      soap->minimum;
  846.         break;
  847.       }
  848.     }
  849.     return newrr;
  850. }
  851.  
  852.  
  853. /**
  854.  **     Domain Cache Utilities
  855.  **/
  856.  
  857. static void
  858. dcache_add(rrlp)
  859. register struct rr *rrlp;
  860. {
  861.     register struct rr *last_rrp;
  862.     struct rr *save_rrp;
  863.  
  864.     if(rrlp == NULLRR)
  865.         return;
  866.  
  867.     save_rrp = rrlp;
  868.     last_rrp = NULLRR;
  869.     while(rrlp != NULLRR){
  870.         rrlp->last = last_rrp;
  871.         last_rrp = rrlp;
  872.         rrlp = rrlp->next;
  873.     }
  874.     last_rrp->next = Dcache;
  875.     if(Dcache != NULLRR)
  876.         Dcache->last = last_rrp;
  877.     Dcache = save_rrp;
  878. }
  879.  
  880. static void
  881. dcache_drop(rrp)
  882. register struct rr *rrp;
  883. {
  884.     if(rrp->last != NULLRR)
  885.         rrp->last->next = rrp->next;
  886.     else
  887.         Dcache = rrp->next;
  888.     if(rrp->next != NULLRR)
  889.         rrp->next->last = rrp->last;
  890.     rrp->last =
  891.     rrp->next = NULLRR;
  892. }
  893.  
  894. /* Search cache for resource records, removing them from the cache.
  895.  * Also, timeout cache entries, and trim cache to size.
  896.  * (Calling with NULLRR is legal -- will timeout & trim only.)
  897.  * Note that an answer from the cache cannot be authoritative, because
  898.  * we cannot guarantee that all the entries remain from a previous request.
  899.  * Returns RR list, or NULLRR if no record found.
  900.  */
  901. static struct rr *
  902. dcache_search(rrlp)
  903. struct rr *rrlp;
  904. {
  905.     register struct rr *rrp, *test_rrp;
  906.     struct rr **rrpp, *result_rrlp;
  907.     int32 elapsed;
  908.     time_t now;
  909.     int count = 0;
  910.  
  911. #ifdef DEBUG
  912.     if(Dtrace && rrlp != NULLRR){
  913.         tprintf("dcache_search: searching for %s\n",rrlp->name);
  914.     }
  915. #endif
  916.  
  917.     elapsed = (int32)(time(&now) - Dcache_time);
  918.     Dcache_time = now;
  919.  
  920.     rrpp = &result_rrlp;
  921.     for(rrp = Dcache; (test_rrp = rrp) != NULLRR;){
  922.         rrp = rrp->next;
  923.                     /* timeout entries */
  924.         if(test_rrp->ttl > 0L
  925.         && (test_rrp->ttl -= elapsed) <= 0L)
  926.             test_rrp->ttl = 0L;
  927.  
  928.         if(compare_rr_list(rrlp,test_rrp) == 0){
  929.             dcache_drop( *rrpp = test_rrp );
  930.             rrpp = &(*rrpp)->next;
  931.         } else if(test_rrp->source == RR_FILE && ++count > Dcache_size){
  932.             dcache_drop(test_rrp);
  933.             free_rr(test_rrp);
  934.         }
  935.     }
  936.     *rrpp = NULLRR;
  937.     return result_rrlp;
  938. }
  939.  
  940. /* Move a list of resource records to the cache, removing duplicates. */
  941. static void
  942. dcache_update(rrlp)
  943. register struct rr *rrlp;
  944. {
  945.     if(rrlp == NULLRR)
  946.         return;
  947.  
  948.     free_rr(dcache_search(rrlp));   /* remove duplicates, first */
  949.     dcache_add(rrlp);
  950. }
  951.  
  952.  
  953. /**
  954.  **     File Utilities
  955.  **/
  956.  
  957. static struct rr *
  958. get_rr(fp,lastrrp)
  959. FILE *fp;
  960. struct rr *lastrrp;
  961. {
  962. #ifndef ATARI
  963.     char *line,*lp,*strtok();
  964. #else
  965.     char *line, *lp;
  966. #endif
  967.     struct rr *rrp;
  968.     char *name,*ttl,*class,*type,*data;
  969.     int i;
  970.  
  971.     line = mallocw(500);
  972.     if(fgets(line,500,fp) == NULL){
  973.         free(line);
  974.         return NULLRR;
  975.         }
  976.  
  977.     if (strchr(line, '('))
  978.         {
  979.         int done;
  980.         char *big_line, *p;
  981.         p = line;
  982.         while (*p && *p != '(')
  983.             p++;
  984.         *p = '\0';
  985.         big_line = mallocw(500);
  986.         if (big_line == NULL)
  987.             {
  988.             free(line);
  989.             return NULLRR;
  990.             }
  991.         strcpy(big_line, line);
  992.         done = FALSE;
  993.         while (fgets(line, 500, fp) && !done)
  994.             {
  995.             if (strchr(line, ')'))
  996.                 done = TRUE;
  997.             p = line;
  998.             while (*p && *p != ')' && *p != ';')
  999.                 p++;
  1000.             *p = '\0';
  1001.             p = line;
  1002.             while (*p && (*p == ' ' || *p == '\t'))
  1003.                 p++;
  1004.             strcat(big_line, " ");
  1005.             strcat(big_line, p);
  1006.             }
  1007.         strcpy(line, big_line);
  1008.         free(big_line);
  1009.         }
  1010.  
  1011.     rrp = (struct rr *)callocw(1,sizeof(struct rr));
  1012.     rrp->source = RR_FILE;
  1013.  
  1014.     if(line[0] == '\0' || line[0] == '#' || line[0] == ';'){
  1015.         rrp->comment = line;
  1016.         return rrp;
  1017.     }
  1018.  
  1019.     if(!isspace(line[0]) || lastrrp == NULLRR){
  1020.         name = strtok(line,delim);
  1021.         lp = NULLCHAR;
  1022.     } else {        /* Name field is missing */
  1023.         name = lastrrp->name;
  1024.         lp = line;
  1025.     }
  1026.     if(name == NULLCHAR || (i = strlen(name)) == 0){
  1027.         rrp->comment = strdup("\n");
  1028.         free(line);
  1029.         return rrp;
  1030.     }
  1031.  
  1032.     if(name[i-1] != '.'){
  1033.         /* Tack on a trailing period if it's not there */
  1034.         /* !!! need to implement $ORIGIN suffix here */
  1035.         rrp->name = mallocw(i+2);
  1036.         strcpy(rrp->name,name);
  1037.         strcat(rrp->name,".");
  1038.     } else
  1039.         rrp->name = strdup(name);
  1040.  
  1041.     ttl = strtok(lp,delim);
  1042.  
  1043.     if(ttl == NULLCHAR || (!isdigit(ttl[0]) && ttl[0] != '-')){
  1044.         /* Optional ttl field is missing */
  1045.         rrp->ttl = TTL_MISSING;
  1046.         class = ttl;
  1047.     } else {
  1048.         rrp->ttl = atol(ttl);
  1049.         class = strtok(NULLCHAR,delim);
  1050.     }
  1051.  
  1052.     if(class == NULLCHAR){
  1053.         /* we're in trouble, but keep processing */
  1054.         rrp->class = CLASS_MISSING;
  1055.         type = class;
  1056.     } else if(class[0] == '<'){
  1057.         rrp->class = atoi(&class[1]);
  1058.         type = strtok(NULLCHAR,delim);
  1059.     } else if(stricmp(class,"IN") == 0){
  1060.         rrp->class = CLASS_IN;
  1061.         type = strtok(NULLCHAR,delim);
  1062.     } else {
  1063.         /* Optional class field is missing; assume IN */
  1064.         rrp->class = CLASS_IN;
  1065.         type = class;
  1066.     }
  1067.  
  1068.     if(type == NULLCHAR){
  1069.         /* we're in trouble, but keep processing */
  1070.         rrp->type = TYPE_MISSING;
  1071.         data = type;
  1072.     } else if(type[0] == '{'){
  1073.         rrp->type = atoi(&class[1]);
  1074.         data = strtok(NULLCHAR,delim);
  1075.     } else {
  1076.         rrp->type = TYPE_MISSING;
  1077.         for(i=1;i<Ndtypes;i++){
  1078.             if(stricmp(type,Dtypes[i]) == 0){
  1079.                 rrp->type = i;
  1080.                 data = strtok(NULLCHAR,delim);
  1081.                 break;
  1082.             }
  1083.         }
  1084.     }
  1085.  
  1086.     if(rrp->type == TYPE_MISSING){
  1087.         data = NULLCHAR;
  1088.     }
  1089.  
  1090.     if(data == NULLCHAR){
  1091.         /* Empty record, just return */
  1092.         free(line);
  1093.         return rrp;
  1094.     }
  1095.     switch(rrp->type){
  1096.     case TYPE_A:
  1097.         rrp->rdlength = 4;
  1098.         rrp->rdata.addr = aton(data);
  1099.         break;
  1100.     case TYPE_CNAME:
  1101.     case TYPE_MB:
  1102.     case TYPE_MG:
  1103.     case TYPE_MR:
  1104.     case TYPE_NS:
  1105.     case TYPE_PTR:
  1106.     case TYPE_TXT:
  1107.         rrp->rdlength = strlen(data);
  1108.         rrp->rdata.name = strdup(data);
  1109.         break;
  1110.     case TYPE_HINFO:
  1111.         rrp->rdlength = strlen(data);
  1112.         rrp->rdata.hinfo.cpu = strdup(data);
  1113.         if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1114.             rrp->rdlength += strlen(data);
  1115.             rrp->rdata.hinfo.os = strdup(data);
  1116.         }
  1117.         break;
  1118.     case TYPE_MX:
  1119.         rrp->rdata.mx.pref = atoi(data);
  1120.         rrp->rdlength = 2;
  1121.  
  1122.         /* Get domain name of exchanger */
  1123.         if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1124.             rrp->rdlength += strlen(data);
  1125.             rrp->rdata.mx.exch = strdup(data);
  1126.         }
  1127.         break;
  1128.     case TYPE_SOA:
  1129.         /* Get domain name of master name server */
  1130.         rrp->rdlength = strlen(data);
  1131.         rrp->rdata.soa.mname = strdup(data);
  1132.  
  1133.         /* Get domain name of irresponsible person */
  1134.         if((data = strtok(NULLCHAR,delim)) != NULLCHAR){
  1135.             rrp->rdata.soa.rname = strdup(data);
  1136.             rrp->rdlength += strlen(data);
  1137.         }
  1138.         data = strtok(NULLCHAR,delim);
  1139.         rrp->rdata.soa.serial = atol(data);
  1140.         data = strtok(NULLCHAR,delim);
  1141.         rrp->rdata.soa.refresh = atol(data);
  1142.         data = strtok(NULLCHAR,delim);
  1143.         rrp->rdata.soa.retry = atol(data);
  1144.         data = strtok(NULLCHAR,delim);
  1145.         rrp->rdata.soa.expire = atol(data);
  1146.         data = strtok(NULLCHAR,delim);
  1147.         rrp->rdata.soa.minimum = atol(data);
  1148.         rrp->rdlength += 20;
  1149.         break;
  1150.     }
  1151.  
  1152.     /* !!! need to handle trailing comments */
  1153.     free(line);
  1154.     return rrp;
  1155. }
  1156.  
  1157. static void sofprintf(FILE *fp, char * fmt, ...)
  1158. { 
  1159.  /*
  1160.     This routine behaves like the standard fprintf() except
  1161.     for when the destination is stdout. In this case write
  1162.     to the current process' output socket.
  1163.  */
  1164.  char * buf;
  1165.  va_list args;
  1166.  buf = mallocw(1024); /* Big enough for most strings... (cf sockuser.c) */
  1167.  va_start(args, fmt);
  1168.  vsprintf(buf, fmt, args);
  1169.  va_end(args);
  1170.  if (fp == stdout)
  1171.     usputs(Curproc->output, buf);
  1172.  else fputs(buf, fp);
  1173.  free(buf);
  1174. }
  1175.  
  1176. /* Print a resource record */
  1177. static void
  1178. put_rr(fp,rrp)
  1179. FILE *fp;
  1180. struct rr *rrp;
  1181. {
  1182.     char * stuff;
  1183.  
  1184.     if(fp == NULLFILE || rrp == NULLRR)
  1185.         return;
  1186.  
  1187.     if(rrp->name == NULLCHAR && rrp->comment != NULLCHAR){
  1188.         sofprintf(fp,"%s",rrp->comment);
  1189.         return;
  1190.     }
  1191.  
  1192.     sofprintf(fp,"%s",rrp->name);
  1193.     if(rrp->ttl != TTL_MISSING)
  1194.         sofprintf(fp,"\t%ld",rrp->ttl);
  1195.     if(rrp->class == CLASS_IN)
  1196.         sofprintf(fp,"\tIN");
  1197.     else
  1198.         sofprintf(fp,"\t<%u>",rrp->class);
  1199.  
  1200.     stuff = dtype(rrp->type);
  1201.     sofprintf(fp,"\t%s",stuff);
  1202.     if(rrp->rdlength == 0){
  1203.         /* Null data portion, indicates nonexistent record */
  1204.         /* or unsupported type.  Hopefully, these will filter */
  1205.         /* as time goes by. */
  1206.         sofprintf(fp,"\n");
  1207.         return;
  1208.     }
  1209.     switch(rrp->type){
  1210.     case TYPE_A:
  1211.         sofprintf(fp,"\t%s\n",inet_ntoa(rrp->rdata.addr));
  1212.         break;
  1213.     case TYPE_CNAME:
  1214.     case TYPE_MB:
  1215.     case TYPE_MG:
  1216.     case TYPE_MR:
  1217.     case TYPE_NS:
  1218.     case TYPE_PTR:
  1219.     case TYPE_TXT:
  1220.         /* These are all printable text strings */
  1221.         sofprintf(fp,"\t%s\n",rrp->rdata.data);
  1222.         break;
  1223.     case TYPE_HINFO:
  1224.         sofprintf(fp,"\t%s\t%s\n",
  1225.          rrp->rdata.hinfo.cpu,
  1226.          rrp->rdata.hinfo.os);
  1227.         break;
  1228.     case TYPE_MX:
  1229.         sofprintf(fp,"\t%u\t%s\n",
  1230.          rrp->rdata.mx.pref,
  1231.          rrp->rdata.mx.exch);
  1232.         break;
  1233.     case TYPE_SOA:
  1234.         sofprintf(fp,"\t%s\t%s\t%lu\t%lu\t%lu\t%lu\t%lu\n",
  1235.          rrp->rdata.soa.mname,rrp->rdata.soa.rname,
  1236.          rrp->rdata.soa.serial,rrp->rdata.soa.refresh,
  1237.          rrp->rdata.soa.retry,rrp->rdata.soa.expire,
  1238.          rrp->rdata.soa.minimum);
  1239.         break;
  1240.     default:
  1241.         sofprintf(fp,"\n");
  1242.         break;
  1243.     }
  1244. }
  1245.  
  1246. /* Search local database for resource records.
  1247.  * Returns RR list, or NULLRR if no record found.
  1248.  */
  1249. static struct rr *
  1250. dfile_search(rrlp, filename)
  1251. struct rr *rrlp;
  1252. char *filename;
  1253. {
  1254.     int counter;
  1255.     register struct rr *frrp;
  1256.     struct rr **rrpp, *result_rrlp, *oldrrp;
  1257.     int32 elapsed;
  1258.     FILE *dbase;
  1259.     struct stat dstat;
  1260.     char *this_dfile;
  1261.  
  1262. #ifdef DEBUG
  1263.     if(Dtrace){
  1264.         tprintf("dfile_search: searching for %s\n",rrlp->name);
  1265.     }
  1266. #endif
  1267.  
  1268. #ifdef DSERVER
  1269.     if (filename)
  1270.         {
  1271.         if(Dtrace) {
  1272.             tprintf("dfile_search: searching local zone file %s\n", filename);
  1273.             }
  1274.         this_dfile = mallocw(strlen(Dzones) + 15);
  1275.         sprintf(this_dfile, "%s/%s", Dzones, filename);
  1276.         }
  1277.     else
  1278. #endif
  1279.         this_dfile = Dfile;
  1280.  
  1281.     while(Dfile_writing > 0)
  1282.         pwait(&Dfile_reading);
  1283.     Dfile_reading++;
  1284.  
  1285.     if((dbase = fopen(this_dfile,READ_TEXT)) == NULLFILE){
  1286.         Dfile_reading--;
  1287.         return NULLRR;
  1288.     }
  1289.     if(fstat(fileno(dbase),&dstat) != 0){
  1290.         tprintf("dfile_search: can't get file status\n");
  1291.         fclose(dbase);
  1292.         Dfile_reading--;
  1293.         return NULLRR;
  1294.     }
  1295.     if((elapsed = (int32)(Dcache_time - (time_t)dstat.st_ctime)) < 0L)
  1296.         elapsed = -elapsed;     /* arbitrary time mismatch */
  1297.  
  1298.     result_rrlp = NULLRR;           /* for contiguous test below */
  1299.     oldrrp = NULLRR;
  1300.     rrpp = &result_rrlp;
  1301.     counter = 0;
  1302.     while((frrp = get_rr(dbase,oldrrp)) != NULLRR){
  1303.         if (++counter == 100)
  1304.             {
  1305.             pwait(NULL);
  1306.             counter = 0;
  1307.             }
  1308.         free_rr(oldrrp);
  1309.         if(frrp->type != TYPE_MISSING
  1310.         && frrp->rdlength > 0
  1311.         && compare_rr_list(rrlp,frrp) == 0){
  1312.             if(frrp->ttl > 0L
  1313.             && (frrp->ttl -= elapsed) <= 0L)
  1314.                 frrp->ttl = 0L;
  1315.             *rrpp = frrp;
  1316.             rrpp = &(*rrpp)->next;
  1317.             oldrrp = copy_rr(frrp);
  1318.         } else {
  1319.             oldrrp = frrp;
  1320.             /*
  1321.                 All records of the same name and the same type
  1322.                 are contiguous.  Therefore, for a single query,
  1323.                 we can stop searching.  Multiple queries must
  1324.                 read the whole file.
  1325.  
  1326.                 Unless we're primary!
  1327.             */
  1328.             if(rrlp->type != TYPE_ANY
  1329.             && rrlp->next == NULLRR
  1330.             && result_rrlp != NULLRR
  1331. #ifdef DSERVER
  1332.             && filename == NULL
  1333. #endif
  1334.             )
  1335.                 break;
  1336.         }
  1337.         if(!main_exit)
  1338.             pwait(NULL);    /* run multiple sessions */
  1339.     }
  1340.     free_rr(oldrrp);
  1341.     *rrpp = NULLRR;
  1342.  
  1343.     fclose(dbase);
  1344.  
  1345.     if(--Dfile_reading <= 0){
  1346.         Dfile_reading = 0;
  1347.         psignal(&Dfile_writing,0);
  1348.     }
  1349.  
  1350. #ifdef DSERVER
  1351.     if (filename)
  1352.         free(this_dfile);
  1353. #endif
  1354.  
  1355.     return result_rrlp;
  1356. }
  1357.  
  1358. /* Process which will add new resource records from the cache
  1359.  * to the local file, eliminating duplicates while it goes.
  1360.  */
  1361. static void __stdargs
  1362. dfile_update(s,unused,p)
  1363. int s;
  1364. void *unused;
  1365. void *p;
  1366. {
  1367.     struct rr **rrpp, *rrlp, *oldrrp;
  1368.     char *newname;
  1369.     FILE *old_fp, *new_fp;
  1370.     struct stat old_stat, new_stat;
  1371.  
  1372.     log(-1,"update Domain.txt initiated");
  1373.  
  1374.     close_s(Curproc->input);
  1375.     usesock(Curproc->input = Cmdpp->input);
  1376.     close_s(Curproc->output);
  1377.     usesock(Curproc->output = Cmdpp->output);
  1378.  
  1379.     newname = strdup(Dfile);
  1380.     strcpy(&newname[strlen(newname)-3],"tmp");
  1381.  
  1382.     while(Dfile_wait_absolute != 0L && !main_exit){
  1383.         register struct rr *frrp;
  1384.         int32 elapsed;
  1385.  
  1386.         while(Dfile_wait_absolute != 0L){
  1387.             elapsed = Dfile_wait_absolute - secclock();
  1388.             Dfile_wait_absolute = 0L;
  1389.             if(elapsed > 0L && !main_exit){
  1390.                 alarm(elapsed*1000L);
  1391.                 pwait(&Dfile_wait_absolute);
  1392.                 alarm(0L);
  1393.             }
  1394.         }
  1395.  
  1396.         log(-1,"update Domain.txt");
  1397.  
  1398.         /* create new file for copy */
  1399.         if((new_fp = fopen(newname,WRITE_TEXT)) == NULLFILE){
  1400.             tprintf("dfile_update: can't create %s!\n",newname);
  1401.             break;
  1402.         }
  1403.         if(fstat(fileno(new_fp),&new_stat) != 0){
  1404.             tprintf("dfile_update: can't get new_file status!\n");
  1405.             fclose(new_fp);
  1406.             break;
  1407.         }
  1408.  
  1409.         pwait(NULL);    /* file operations can be slow */
  1410.  
  1411.         /* timeout the cache one last time before writing */
  1412.         (void)dcache_search(NULLRR);
  1413.  
  1414.         /* copy new RRs out to the new file */
  1415.         /* (can't wait here, the cache might change) */
  1416.         rrpp = &rrlp;
  1417.         for(frrp = Dcache; frrp != NULLRR; frrp = frrp->next ){
  1418.             switch(frrp->source){
  1419.             case RR_QUESTION:
  1420.             case RR_ANSWER:
  1421.             case RR_AUTHORITY:
  1422.             case RR_ADDITIONAL:
  1423.                 *rrpp = copy_rr(frrp);
  1424.                 if(frrp->type != TYPE_MISSING
  1425.                 && frrp->rdlength > 0)
  1426.                     put_rr(new_fp,frrp);
  1427.                 rrpp = &(*rrpp)->next;
  1428.                 frrp->source = RR_FILE;
  1429.                 break;
  1430.             }
  1431.         }
  1432.         *rrpp = NULLRR;
  1433.  
  1434.         /* open up the old file, concurrently with everyone else */
  1435.         if((old_fp = fopen(Dfile,READ_TEXT)) == NULLFILE){
  1436.             /* great! no old file, so we're ready to go. */
  1437.             fclose(new_fp);
  1438.             rename(newname,Dfile);
  1439.             free_rr(rrlp);
  1440.             break;
  1441.         }
  1442.         if(fstat(fileno(old_fp),&old_stat) != 0){
  1443.             tprintf("dfile_update: can't get old_file status!\n");
  1444.             fclose(new_fp);
  1445.             fclose(old_fp);
  1446.             free_rr(rrlp);
  1447.             break;
  1448.         }
  1449.         if((elapsed = (int32)(new_stat.st_ctime - old_stat.st_ctime)) < 0L)
  1450.             elapsed = -elapsed;     /* file times are inconsistant */
  1451.  
  1452.         /* Now append any non-duplicate records */
  1453.         oldrrp = NULLRR;
  1454.         while((frrp = get_rr(old_fp,oldrrp)) != NULLRR){
  1455.             free_rr(oldrrp);
  1456.             if(frrp->name == NULLCHAR
  1457.             && frrp->comment != NULLCHAR)
  1458.                 put_rr(new_fp,frrp);
  1459.             if(frrp->type != TYPE_MISSING
  1460.             && frrp->rdlength > 0
  1461.             && compare_rr_list(rrlp,frrp) != 0){
  1462.                 if(frrp->ttl > 0L
  1463.                 && (frrp->ttl -= elapsed) <= 0L)
  1464.                     frrp->ttl = 0L;
  1465.                 if(frrp->ttl != 0 || !Dfile_clean)
  1466.                     put_rr(new_fp,frrp);
  1467.             }
  1468.             oldrrp = frrp;
  1469.             if(!main_exit)
  1470.                 pwait(NULL);    /* run in background */
  1471.         }
  1472.         free_rr(oldrrp);
  1473.         fclose(new_fp);
  1474.         fclose(old_fp);
  1475.         free_rr(rrlp);
  1476.  
  1477.         /* wait for everyone else to finish reading */
  1478.         Dfile_writing++;
  1479.         while(Dfile_reading > 0)
  1480.             pwait(&Dfile_writing);
  1481.  
  1482.         unlink(Dfile);
  1483.         rename(newname,Dfile);
  1484.  
  1485.         Dfile_writing = 0;
  1486.         psignal(&Dfile_reading,0);
  1487.     }
  1488.     free(newname);
  1489.  
  1490.     log(-1,"update Domain.txt finished");
  1491.     Dfile_updater = NULLPROC;
  1492. }
  1493.  
  1494.  
  1495. /**
  1496.  **     Domain Server Utilities
  1497.  **/
  1498.  
  1499. static void
  1500. dumpdomain(dhp,rtt)
  1501. struct dhdr *dhp;
  1502. int32 rtt;
  1503. {
  1504.     struct rr *rrp;
  1505.     char * stuff;
  1506.  
  1507.     tprintf("response id %u (rtt %lu sec) qr %u opcode %u aa %u tc %u rd %u ra %u rcode %u\n",
  1508.      dhp->id,(long)rtt / 1000L,
  1509.      dhp->qr,dhp->opcode,dhp->aa,dhp->tc,dhp->rd,
  1510.      dhp->ra,dhp->rcode);
  1511.     tprintf("%u questions:\n",dhp->qdcount);
  1512.     for(rrp = dhp->questions; rrp != NULLRR; rrp = rrp->next){
  1513.         stuff = dtype(rrp->type);
  1514.         tprintf("%s type %s class %u\n",rrp->name,
  1515.          stuff,rrp->class);
  1516.     }
  1517.     tprintf("%u answers:\n",dhp->ancount);
  1518.     for(rrp = dhp->answers; rrp != NULLRR; rrp = rrp->next){
  1519.         put_rr(stdout,rrp);
  1520.     }
  1521.     tprintf("%u authority:\n",dhp->nscount);
  1522.     for(rrp = dhp->authority; rrp != NULLRR; rrp = rrp->next){
  1523.         put_rr(stdout,rrp);
  1524.     }
  1525.     tprintf("%u additional:\n",dhp->arcount);
  1526.     for(rrp = dhp->additional; rrp != NULLRR; rrp = rrp->next){
  1527.         put_rr(stdout,rrp);
  1528.     }
  1529.     fflush(stdout);
  1530. }
  1531.  
  1532. static int
  1533. dns_makequery(
  1534.     int16 op,               /* operation */
  1535.     struct rr *srrp,        /* Search RR */
  1536.     char *buffer,           /* Area for query */
  1537.     int16 buflen)           /* Length of same */
  1538. {
  1539.     char *cp,*cp1;
  1540.     char *dname, *sname;
  1541.     int16 parameter;
  1542.     int16 dlen,len;
  1543.  
  1544.     cp = buffer;
  1545.     /* Use millisecond clock for timestamping */
  1546.     cp = put16(cp,(int16)msclock());
  1547.     parameter = (op << 11)
  1548.             | 0x0100;       /* Recursion desired */
  1549.     cp = put16(cp,parameter);
  1550.     cp = put16(cp,1);
  1551.     cp = put16(cp,0);
  1552.     cp = put16(cp,0);
  1553.     cp = put16(cp,0);
  1554.  
  1555.     sname = strdup(srrp->name);
  1556.     dname = sname;
  1557.     dlen = strlen(dname);
  1558.     for(;;){
  1559.         /* Look for next dot */
  1560.         cp1 = strchr(dname,'.');
  1561.         if(cp1 != NULLCHAR)
  1562.             len = cp1-dname;        /* More to come */
  1563.         else
  1564.             len = dlen;     /* Last component */
  1565.         *cp++ = len;            /* Write length of component */
  1566.         if(len == 0)
  1567.             break;
  1568.         /* Copy component up to (but not including) dot */
  1569.         strncpy(cp,dname,len);
  1570.         cp += len;
  1571.         if(cp1 == NULLCHAR){
  1572.             *cp++ = 0;      /* Last one; write null and finish */
  1573.             break;
  1574.         }
  1575.         dname += len+1;
  1576.         dlen -= len+1;
  1577.     }
  1578.     free(sname);
  1579.     cp = put16(cp,srrp->type);
  1580.     cp = put16(cp,srrp->class);
  1581.     return (int) (cp - buffer);
  1582. }
  1583.  
  1584. /* domain server resolution loop
  1585.  * returns: any answers in cache.
  1586.  *      (future features)
  1587.  *      multiple queries.
  1588.  *      inverse queries.
  1589.  */
  1590. static void
  1591. dns_query(rrlp)
  1592. struct rr *rrlp;
  1593. {
  1594.     struct mbuf *bp;
  1595.     struct dhdr *dhp;
  1596.     struct dserver *dp;     /* server list */
  1597.     int32 rtt,abserr;
  1598.     int tried = 0;          /* server list has been retried (count) */
  1599.  
  1600.     if((dp = Dservers) == NULLDOM){
  1601.         return;
  1602.     }
  1603.  
  1604.     for(;;){
  1605.         char *buf;
  1606.         int len;
  1607.         struct sockaddr_in server_in;
  1608.         int s;
  1609.         int rval;
  1610.  
  1611.         dp->queries++;
  1612.  
  1613.         s = socket(AF_INET,SOCK_DGRAM,0);
  1614.         server_in.sin_family = AF_INET;
  1615.         server_in.sin_port = IPPORT_DOMAIN;
  1616.         server_in.sin_addr.s_addr = dp->address;
  1617.  
  1618.         if(Dtrace){
  1619.             tprintf("dns_query: querying server %s for %s\n",
  1620.              inet_ntoa(dp->address),rrlp->name);
  1621.         }
  1622.  
  1623.         buf = mallocw(512);
  1624.         len = dns_makequery(0,rrlp,buf,512);
  1625.         sendto(s,buf,len,0,(char *)&server_in,sizeof(server_in));
  1626.         free(buf);
  1627.         alarm(max(dp->timeout,100));
  1628.         /* Wait for something to happen */
  1629.         rval = recv_mbuf(s,&bp,0,NULLCHAR,0);
  1630.         alarm(0L);
  1631.         close_s(s);
  1632.  
  1633.         if(Dtrace){
  1634.             tprintf("dns_query: received message length %d, errno %d\n", rval, errno );
  1635.         }
  1636.  
  1637.         if(rval > 0)
  1638.             break;
  1639.  
  1640.         if(errno == EABORT){
  1641.             return;         /* Killed by "reset" command */
  1642.         }
  1643.  
  1644.         /* Timeout; back off this one and try another server */
  1645.         dp->timeouts++;
  1646.         dp->timeout <<= 1;
  1647.         /* There may be a limit to how long we will wait */
  1648.         if(Dserver_maxwait && dp->timeout > (Dserver_maxwait * 1000L))
  1649.                                         dp->timeout = Dserver_maxwait * 1000L;
  1650.  
  1651.         if((dp = dp->next) == NULLDOM){
  1652.             dp = Dservers;
  1653.             if(Dserver_retries > 0 && ++tried > Dserver_retries)
  1654.                 {
  1655.                 if (Dserver_maxwait == 0)
  1656.                     /* Only if not specified the maximum wait - MT Oct 92 */
  1657.                     {
  1658.                     /* Reset timeouts  - GT 07 Jun 92. */
  1659.                     while (dp != NULLDOM)
  1660.                         {
  1661.                         dp->timeout = 2 * dp->mdev + dp->srtt + 3;
  1662.                         dp = dp->next;
  1663.                         }
  1664.                     }       
  1665.                 dp = Dservers;
  1666.                 return;
  1667.                 }
  1668.         }
  1669.     }
  1670.  
  1671.     /* got a response */
  1672.     dp->responses++;
  1673.     dhp = (struct dhdr *) mallocw(sizeof(struct dhdr));
  1674.     ntohdomain(dhp,&bp);    /* Convert to local format */
  1675.  
  1676.     /* Compute and update the round trip time */
  1677.     rtt = (int32) ((int16)msclock() - dhp->id);
  1678.     abserr = rtt > dp->srtt ? rtt - dp->srtt : dp->srtt - rtt;
  1679.     dp->srtt = ((AGAIN-1) * dp->srtt + rtt + (AGAIN/2)) >> LAGAIN;
  1680.     dp->mdev = ((DGAIN-1) * dp->mdev + abserr + (DGAIN/2)) >> LDGAIN;
  1681.     dp->timeout = 4 * dp->mdev + dp->srtt;
  1682.  
  1683.     /* move to top of list for next time */
  1684.     if(dp->prev != NULLDOM){
  1685.         dlist_drop(dp);
  1686.         dlist_add(dp);
  1687.     }
  1688.  
  1689.     if(Dtrace)
  1690.         dumpdomain(dhp,rtt);
  1691.  
  1692.     /* Add negative reply to answers.  This assumes that there was
  1693.      * only one question, which is true for all questions we send.
  1694.      */
  1695.     if(dhp->aa && (dhp->rcode == NAME_ERROR || dhp->ancount == 0)){
  1696.         register struct rr *rrp;
  1697.         long ttl = 600L; /* Default TTL for negative records */
  1698.  
  1699.         /* look for SOA ttl */
  1700.         for(rrp = dhp->authority; rrp != NULLRR; rrp = rrp->next){
  1701.             if(rrp->type == TYPE_SOA)
  1702.                 ttl = rrp->ttl;
  1703.         }
  1704.  
  1705.         /* make the questions the negative answers */
  1706.         for(rrp = dhp->questions; rrp != NULLRR; rrp = rrp->next)
  1707.             rrp->ttl = ttl;
  1708.     } else {
  1709.         free_rr(dhp->questions);
  1710.         dhp->questions = NULLRR;
  1711.     }
  1712.  
  1713.     /* post in reverse order to maintain original order */
  1714.     dcache_update(dhp->additional);
  1715.     dcache_update(dhp->authority);
  1716.     dcache_update(dhp->answers);
  1717.     dcache_update(dhp->questions);
  1718.  
  1719.     Dfile_wait_absolute = secclock() + Dfile_wait_relative;
  1720.     if(Dfile_updater == NULLPROC){
  1721.         Dfile_updater = newproc("domain update",
  1722.             512,dfile_update,0,NULL,NULL,0);
  1723.     }
  1724.  
  1725. #ifdef DEBUG
  1726.     if(Dtrace)
  1727.         keywait(NULLCHAR,1);    /* so we can look around */
  1728. #endif
  1729.     free((char *)dhp);
  1730.     return;
  1731. }
  1732.  
  1733.  
  1734. /**
  1735.  **     Resolver Utilities
  1736.  **/
  1737.  
  1738. /* Return TRUE if string appears to be an IP address in dotted decimal;
  1739.  * return FALSE otherwise (i.e., if string is a domain name)
  1740.  */
  1741. static int
  1742. isaddr(s)
  1743. register char *s;
  1744. {
  1745.     char c;
  1746.  
  1747.     if(s == NULLCHAR)
  1748.         return TRUE;    /* Can't happen */
  1749.  
  1750.     while((c = *s++) != '\0'){
  1751.         if(c != '[' && c != ']' && !isdigit(c) && c != '.')
  1752.             return FALSE;
  1753.     }
  1754.     return TRUE;
  1755. }
  1756.  
  1757. /* Return "normalized" domain name, with default suffix and trailing '.'
  1758.  */
  1759. static char *
  1760. checksuffix(dname)
  1761. char *dname;
  1762. {
  1763.     char *sname, *tname;
  1764.  
  1765.     sname = strdup(dname);
  1766.     if(strchr(sname,'.') == NULLCHAR && Dsuffix != NULLCHAR){
  1767.         /* Append default suffix */
  1768.         tname = mallocw(strlen(sname)+strlen(Dsuffix)+2);
  1769.         sprintf(tname,"%s.%s",sname,Dsuffix);
  1770.         free(sname);
  1771.         sname = tname;
  1772.     }
  1773.     if(sname[strlen(sname)-1] != '.'){
  1774.         /* Append trailing dot */
  1775.         tname = mallocw(strlen(sname)+2);
  1776.         sprintf(tname,"%s.",sname);
  1777.         free(sname);
  1778.         sname = tname;
  1779.     }
  1780.     return sname;
  1781. }
  1782.  
  1783. #ifdef DSERVER
  1784.  
  1785. char *zone_filename(char *domain, int32 *expire)
  1786. {
  1787.     struct DOM_FILE *t_dom_file;
  1788.     char *name;
  1789.     int len;
  1790.     len = strlen(domain);
  1791.     name = mallocw(len + 2);
  1792.     strcpy(name, domain);
  1793.     if (name[len - 1] != '.')
  1794.         {
  1795.         strcat(name, ".");
  1796.         len++;
  1797.         }
  1798.     t_dom_file = dom_file;
  1799.     while (Drx != NULLPROC && t_dom_file)
  1800.         {
  1801.         if (stricmp(t_dom_file->domain, name + len
  1802.                                         - strlen(t_dom_file->domain)) == 0)
  1803.             {
  1804.             if (expire)
  1805.                 *expire = t_dom_file->dom_soa.expire;
  1806.             if (Dtrace)
  1807.                 tprintf("DNS: Using file %s\n", t_dom_file->filename);
  1808.             free(name);
  1809.             return t_dom_file->filename;
  1810.             }
  1811.         t_dom_file = t_dom_file->next;
  1812.         }
  1813.     free(name);
  1814.     return NULL;
  1815. }
  1816.  
  1817. #endif
  1818.  
  1819. /*
  1820.     resolver - Search for resource records.
  1821.               Returns RR list, or NULLRR if no record found.
  1822. */
  1823.  
  1824. static struct rr *resolver(struct rr *rrlp)
  1825. {
  1826.     struct rr *result_rrlp;
  1827. #ifdef DSERVER
  1828.     char *t;
  1829.     int32 expire;
  1830.     struct rr *t_rr;
  1831. #endif
  1832.  
  1833. #ifdef DSERVER
  1834.     /*
  1835.     Are we primary for the domain? If so, we must answer from the
  1836.     file cos we can't guarantee that a full set of records for a
  1837.     particular query will be in the cache.
  1838.     */
  1839.     if ((t = zone_filename(rrlp->name, &expire)) != NULL)
  1840.         {
  1841.         result_rrlp = dfile_search(rrlp, t);
  1842.         if (result_rrlp != NULLRR)
  1843.             {
  1844.             t_rr = result_rrlp;
  1845.             while (t_rr)
  1846.                 {
  1847.                 t_rr->ttl = expire;
  1848.                 t_rr = t_rr->next;
  1849.                 }
  1850. /*
  1851. If we never use the cache to answer things we're primary for then there's
  1852. no point in caching the results! MT - G7LEU
  1853.             dcache_add(copy_rr_list(result_rrlp));
  1854. */
  1855.             }
  1856.         return result_rrlp;
  1857.         }
  1858. #endif
  1859.  
  1860.     if((result_rrlp = dcache_search(rrlp)) == NULLRR){
  1861.         result_rrlp = dfile_search(rrlp, NULL);
  1862.     }
  1863.     if(result_rrlp == NULLRR || check_ttl(result_rrlp) != 0){
  1864.         dcache_add(result_rrlp);        /* save any expired RRs */
  1865.         dns_query(rrlp);
  1866.         result_rrlp = dcache_search(rrlp);
  1867.     }
  1868.     dcache_add(copy_rr_list(result_rrlp));
  1869.     return result_rrlp;
  1870. }
  1871.  
  1872. /* general entry point for address -> domain name resolution.
  1873.  * Returns RR list, or NULLRR if no record found.
  1874.  */
  1875. struct rr *
  1876. inverse_a(ip_address)
  1877. int32 ip_address;
  1878. {
  1879.     struct rr *prrp;
  1880.     struct rr *result_rrlp;
  1881.     char pname[30];
  1882.  
  1883.     if(ip_address == 0L)
  1884.         return NULLRR;
  1885.  
  1886.     sprintf( pname, "%u.%u.%u.%u.IN-ADDR.ARPA.",
  1887.             lobyte(loword(ip_address)),
  1888.             hibyte(loword(ip_address)),
  1889.             lobyte(hiword(ip_address)),
  1890.             hibyte(hiword(ip_address)) );
  1891.  
  1892.     prrp = make_rr(RR_QUERY,pname,CLASS_IN,TYPE_PTR,0,0,NULL);
  1893.  
  1894.     prrp->next =            /* make list to speed search */
  1895.         make_rr(RR_INQUERY,NULLCHAR,CLASS_IN,TYPE_A,0,4,&ip_address);
  1896.  
  1897.     result_rrlp = resolver(prrp);
  1898.  
  1899.     free_rr(prrp);
  1900.     return result_rrlp;
  1901. }
  1902.  
  1903. /* general entry point for domain name -> resource resolution.
  1904.  * Returns RR list, or NULLRR if no record found.
  1905.  */
  1906. struct rr *
  1907. resolve_rr(
  1908.     char *dname,
  1909.     int16 dtype)
  1910. {
  1911.     struct rr *qrrp;
  1912.     struct rr *result_rrlp;
  1913.     char *sname;
  1914.     int looping = MAXCNAME;
  1915.  
  1916.     if(dname == NULLCHAR)
  1917.         return NULLRR;
  1918.  
  1919.     sname = checksuffix(dname);
  1920.     qrrp = make_rr(RR_QUERY,sname,CLASS_IN,dtype,0,0,NULL);
  1921.     free(sname);
  1922.  
  1923.     while(looping > 0){
  1924.  
  1925.         /* Change this condition to include TYPE_ANY. ILP 17/2/93 */
  1926.  
  1927.         if((result_rrlp=resolver(qrrp)) == NULLRR
  1928.         || result_rrlp->type == dtype
  1929.         || dtype == TYPE_ANY)
  1930.             break;
  1931. #ifdef DEBUG
  1932.         if(Dtrace)
  1933.             put_rr(stdout,result_rrlp);
  1934. #endif
  1935.         /* Should be CNAME or PTR record */
  1936.         /* Replace name and try again */
  1937.         free(qrrp->name);
  1938.         qrrp->name = strdup(result_rrlp->rdata.name);
  1939.         free_rr(result_rrlp);
  1940.         result_rrlp = NULLRR;
  1941.         looping--;
  1942.     }
  1943.     free_rr(qrrp);
  1944.     return result_rrlp;
  1945. }
  1946.  
  1947. /* main entry point for address -> domain name resolution.
  1948.  * Returns string, or NULLCHAR if no name found.
  1949.  */
  1950. char *
  1951. resolve_a(ip_address,shorten)
  1952. int32 ip_address;               /* search address */
  1953. int shorten;                    /* return only first part of name (flag)*/
  1954. {
  1955.     struct rr *save_rrlp, *rrlp;
  1956.     char *result = NULLCHAR;
  1957.  
  1958.     for( rrlp = save_rrlp = inverse_a(ip_address);
  1959.          rrlp != NULLRR && result == NULLCHAR;
  1960.          rrlp = rrlp->next ){
  1961.         if(rrlp->rdlength > 0){
  1962.             switch(rrlp->type){
  1963.             case TYPE_PTR:
  1964.                 result = strdup(rrlp->rdata.name);
  1965.                 break;
  1966.             case TYPE_A:
  1967.                 result = strdup(rrlp->name);
  1968.                 break;
  1969.             }
  1970.         }
  1971.     }
  1972.     free_rr(save_rrlp);
  1973.  
  1974.     if(result != NULLCHAR && shorten){
  1975.         int dot;
  1976.         char *shortened;
  1977.  
  1978.         if((dot = strcspn(result, ".")) == 0){
  1979.             shortened = mallocw(dot+1);
  1980.             strncpy(shortened, result, dot);
  1981.             shortened[dot] = '\0';
  1982.             free(result);
  1983.             result = shortened;
  1984.         }
  1985.     }
  1986.     return result;
  1987. }
  1988.  
  1989. /* Main entry point for domain name -> address resolution.
  1990.  * Returns 0 if name is currently unresolvable.
  1991.  */
  1992. int32
  1993. resolve(name)
  1994. char *name;
  1995. {
  1996.     register struct rr *rrlp;
  1997.     int32 ip_address = 0;
  1998.  
  1999.     if(name == NULLCHAR)
  2000.         return 0;
  2001.  
  2002.     if(isaddr(name))
  2003.         return aton(name);
  2004.  
  2005.     if((rrlp = resolve_rr(name,TYPE_A)) != NULLRR
  2006.      && rrlp->rdlength > 0)
  2007.         ip_address = rrlp->rdata.addr;
  2008.  
  2009.     /* multi-homed hosts are handled here */
  2010.     if(rrlp != NULLRR && rrlp->next != NULLRR) {
  2011.         register struct rr *rrp;
  2012.         register struct route *rp;
  2013.         int16 cost = MAXINT16;
  2014.         rrp = rrlp;
  2015.         /* choose the best of a set of routes */
  2016.         while(rrp != NULLRR) {
  2017.             if(rrp->rdlength > 0
  2018.              && (rp = rt_lookup(rrp->rdata.addr)) != NULLROUTE
  2019. #if    0
  2020.              && rp->metric <= cost) {
  2021. #endif
  2022.              && rp->metric < cost) {
  2023.                 ip_address = rrp->rdata.addr;
  2024.                 cost = rp->metric;
  2025.             }
  2026.             rrp = rrp->next;
  2027.         }
  2028.     }
  2029.  
  2030.     free_rr(rrlp);
  2031.     return ip_address;
  2032. }
  2033.  
  2034.  
  2035. /* Main entry point for MX record lookup.
  2036.  * Returns 0 if name is currently unresolvable.
  2037.  */
  2038. int32
  2039. resolve_mx(name)
  2040. char *name;
  2041. {
  2042.     register struct rr *rrp, *arrp;
  2043.     char *sname, *tmp, *cp;
  2044.     int32 addr, ip_address = 0;
  2045.     int16 pref = MAXINT16;
  2046.     int our_domain = 0;
  2047.  
  2048.     are_we_an_mx = 0;
  2049.  
  2050. #ifdef DSERVER
  2051.     if (zone_filename(name, NULL))
  2052.         our_domain = 1;
  2053. #endif
  2054.  
  2055.     if(name == NULLCHAR)
  2056.         return 0;
  2057.  
  2058.     if(isaddr(name)){
  2059.         if((sname = resolve_a(aton(name),FALSE)) == NULLCHAR)
  2060.             return 0;
  2061.     }
  2062.     else
  2063.         sname = strdup(name);
  2064.  
  2065.     cp = sname;
  2066.     while(1){
  2067.         rrp = arrp = resolve_rr(sname,TYPE_MX);
  2068.         /* Search this list of rr's for an MX record */
  2069.         while(rrp != NULLRR){
  2070.             if(rrp->rdlength > 0 && (addr = resolve(rrp->rdata.mx.exch)) != 0L)
  2071.                 {
  2072.                 if (addr == Ip_addr)
  2073.                     are_we_an_mx = 1;
  2074.                 if (rrp->rdata.mx.pref <= pref)
  2075.                     {
  2076.                     pref = rrp->rdata.mx.pref;
  2077.                     ip_address = addr;
  2078.                     }
  2079.                 }
  2080.             rrp = rrp->next;
  2081.         }
  2082.         free_rr(arrp);
  2083.         if(ip_address != 0)
  2084.             break;
  2085.         /* If this is our domain we can say no at this point */
  2086.         if (our_domain)
  2087.             break;
  2088.         /* Compose wild card one level up */
  2089.         if((cp = strchr(cp,'.')) == NULLCHAR)
  2090.             break;
  2091.         tmp = mallocw(strlen(cp)+2);
  2092.         sprintf(tmp,"*%s",cp);          /* wildcard expansion */
  2093.         free(sname);
  2094.         sname = tmp;
  2095.         cp = sname + 2;
  2096.     }
  2097.     free(sname);
  2098.     if (Dtrace)
  2099.         tprintf("resolve_mx %s returns %s\n", name, inet_ntoa(ip_address));
  2100.     return ip_address;
  2101. }
  2102.  
  2103. /* Search for local records of the MB, MG and MR type. Returns list of
  2104.  * matching records.
  2105.  */
  2106. struct rr *
  2107. resolve_mailb(name)
  2108. char *name;             /* local username, without trailing dot */
  2109. {
  2110.     register struct rr *result_rrlp;
  2111.     struct rr *rrlp;
  2112.     char *sname;
  2113.  
  2114.     /* Append trailing dot */
  2115.     sname = mallocw(strlen(name)+2);
  2116.     sprintf(sname,"%s.",name);
  2117.     rrlp = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MB,0,0,NULL);
  2118.     rrlp->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MG,0,0,NULL);
  2119.     rrlp->next->next = make_rr(RR_QUERY,sname,CLASS_IN,TYPE_MR,0,0,NULL);
  2120.     free(sname);
  2121.     if((result_rrlp = dcache_search(rrlp)) == NULLRR){
  2122.         result_rrlp = dfile_search(rrlp, NULL);
  2123.     }
  2124.     free_rr(rrlp);
  2125.     if(Dsuffix != NULLCHAR){
  2126.         rrlp = result_rrlp;
  2127.         while(rrlp != NULLRR){  /* add domain suffix to data */
  2128.             if(rrlp->rdlength > 0 &&
  2129.                rrlp->rdata.name[rrlp->rdlength-1] != '.'){
  2130.                 sname = mallocw(rrlp->rdlength +
  2131.                     strlen(Dsuffix)+2);
  2132.                 sprintf(sname,"%s.%s",rrlp->rdata.name,Dsuffix);
  2133.                 free(rrlp->rdata.name);
  2134.                 rrlp->rdata.name = sname;
  2135.                 rrlp->rdlength = strlen(sname);
  2136.             }
  2137.             rrlp = rrlp->next;
  2138.         }
  2139.     }
  2140.     dcache_add(copy_rr_list(result_rrlp));
  2141.     return result_rrlp;
  2142. }
  2143.  
  2144. #ifdef DSERVER
  2145.  
  2146. /* Domain Name Server - based on the server in GRI-Nos 910828
  2147.  * ported to current NOS code by Johan. K. Reinalda, WG7J/PA3DIS
  2148.  * Merged into Demon Internet Services version - MT (g7leu) Sept 1992.
  2149.  * Added primary nameserver - MT (g7leu) October 1992.
  2150.  */
  2151.  
  2152. /* Process a query received by the DNS server */
  2153. static void __stdargs
  2154. proc_query(unused,d,b)
  2155. int unused;
  2156. void *d;
  2157. void *b;
  2158. {
  2159.     struct dserver *dp;
  2160.     struct dhdr *dhdr;
  2161.     int i,len;
  2162.     char *buf;
  2163.     struct sockaddr_in server;
  2164.     struct rr *rrp, *rrans, *rrtmp;
  2165. #ifdef    notdef
  2166.     struct rr *rrns, *rradd, *ap;
  2167. #endif
  2168.     struct rr *qp;
  2169.     int32 expire;
  2170.  
  2171.     dp = (struct dserver *) d;      /* The query address */
  2172.     dhdr = (struct dhdr *) b;       /* The query in host format */
  2173.  
  2174.     rrans = NULLRR;
  2175. #ifdef notdef
  2176.     rrns = rradd = NULLRR;
  2177. #endif
  2178.     qp = dhdr->questions;
  2179.  
  2180.     /* This loop does NOT support multiple questions yet */
  2181. #ifdef notdef
  2182.     for(i=0;i<dhdr->qdcount;i++){
  2183. #endif
  2184.  
  2185.     if(zone_filename(qp->name, &expire))
  2186.         dhdr->aa = 1;
  2187.     else dhdr->aa = 0;
  2188.  
  2189.     switch(qp->type) {
  2190.     case TYPE_A:
  2191.     case TYPE_MX:
  2192.     case TYPE_CNAME:
  2193.     case TYPE_HINFO:
  2194.     case TYPE_PTR:
  2195.     case TYPE_NS:
  2196.     case TYPE_SOA:
  2197.  
  2198.         /* So we can do a dom q <dom.name> from another ka9q ILP 17/2/93 */
  2199.     case TYPE_ANY:
  2200.  
  2201.       /* Not all of the below types are implemented in resolve_rr() */
  2202. #ifdef notdef
  2203.     case TYPE_TXT:
  2204. #endif
  2205.         if((rrp = resolve_rr(qp->name,qp->type)) != NULLRR) {
  2206.         /* we found an entry, go tell him */
  2207.         dhdr->rcode = NO_ERROR;
  2208.         dhdr->qr = RESPONSE;
  2209.                 rrp->ttl = expire;
  2210.         } else {
  2211.         /* we did not find an entry, go tell him */
  2212.         rrp = (struct rr *)callocw(1,sizeof(struct rr));
  2213.         rrp->name = strdup(qp->name);
  2214.         rrp->type = qp->type;
  2215.         rrp->class = qp->class;
  2216.         rrp->ttl = 500L;
  2217.         rrp->rdata.addr = 0L;
  2218.         rrp->rdlength = 4;  /* size of addr data */
  2219.         dhdr->rcode = NAME_ERROR;
  2220.         dhdr->qr = RESPONSE;
  2221.         }
  2222.         rrans = rrp;
  2223.         break;
  2224.     /* Search only the local cache and domain file for these next few */
  2225.     /* Is this a good idea ??? */
  2226.     case TYPE_MB:
  2227.     case TYPE_MG:
  2228.     case TYPE_MR:
  2229.         rrp = make_rr(RR_QUERY,qp->name,CLASS_IN,qp->type,0,0,NULL);
  2230.         if((rrans = dcache_search(rrp)) == NULLRR){
  2231.         rrans = dfile_search(rrp, NULL);
  2232.         }
  2233.         free_rr(rrp);
  2234.         break;
  2235. #ifdef notdef
  2236.     /* Not implemented, yet (?) */
  2237.     case TYPE_MD:
  2238.     case TYPE_MF:
  2239.     case TYPE_WKS:
  2240.     case TYPE_NULL:
  2241.     case TYPE_MINFO:
  2242. #endif
  2243.     default:
  2244.         dhdr->rcode = NOT_IMPL;
  2245.         dhdr->qr = RESPONSE;
  2246.     }
  2247.     /* This loop does NOT support multiple questions yet */
  2248. #ifdef notdef
  2249.     qp = qp->next;  /* next question */
  2250.     }
  2251. #endif
  2252.  
  2253.     /* Find the number of answer records */
  2254.     i = 0;
  2255.     rrtmp = rrans;
  2256.     while(rrtmp != NULLRR) {
  2257.     i++;
  2258.     rrtmp = rrtmp->next;
  2259.     }
  2260.     dhdr->ancount = i;
  2261.     dhdr->answers = rrans;
  2262.  
  2263.     /* Authority & Additional RR's not implemented yet. */
  2264.     dhdr->authority = NULLRR;
  2265.     dhdr->nscount = 0;
  2266.     dhdr->arcount = 0;
  2267.     dhdr->additional = NULLRR;
  2268.  
  2269. #ifdef notdef
  2270.     /* Find the number of authority records */
  2271.     i = 0;
  2272.     rrtmp = rrns;
  2273.     while(rrtmp != NULLRR) {
  2274.     i++;
  2275.     rrtmp = rrtmp->next;
  2276.     }
  2277.     dhdr->nscount = i;
  2278.     dhdr->authority = rrns;
  2279.  
  2280.     /* Find the number of additional records */
  2281.     i = 0;
  2282.     rrtmp = rradd;
  2283.     while(rrtmp != NULLRR) {
  2284.     i++;
  2285.     rrtmp = rrtmp->next;
  2286.     }
  2287.     dhdr->arcount = i;
  2288.     dhdr->additional = rradd;
  2289. #endif
  2290.  
  2291.     if(Dtrace) {
  2292.     tputs("DNS: replying");
  2293.     dumpdomain(dhdr,0);
  2294.     }
  2295.  
  2296.     /* Maximum reply size is 512, see rfc1034/1035 */
  2297.     buf = mallocw(512);
  2298.     len = htondomain(dhdr,buf,512);
  2299.     free_dhdr(dhdr);
  2300.  
  2301.     server.sin_family = AF_INET;
  2302.     server.sin_port = dp->port;
  2303.     server.sin_addr.s_addr = dp->address;
  2304.     sendto(Dsocket,buf,len,0,(char *)&server,sizeof(server));
  2305.     free(buf);
  2306.     free((char *)dp);
  2307. }
  2308.  
  2309.  
  2310. /* Process to receive all domain server related messages */
  2311. static void __stdargs
  2312. drx(unused,u,p)
  2313. int unused;
  2314. void *u;
  2315. void *p;
  2316. {
  2317.     struct sockaddr_in sock,from;
  2318.     int fromlen;
  2319.     struct mbuf *bp;
  2320.     struct dhdr *dhdr;
  2321.     struct dserver *dp;
  2322.     int foo;
  2323.  
  2324.     Dsocket = socket(AF_INET,SOCK_DGRAM,0);
  2325.     sock.sin_family = AF_INET;
  2326.     sock.sin_addr.s_addr = INADDR_ANY;
  2327.     sock.sin_port = IPPORT_DOMAIN;
  2328.     if(bind(Dsocket,(char *)&sock,sizeof(sock)) == -1) {
  2329.     tputs("DNS: can't bind\n");
  2330.         Drx = NULLPROC;
  2331.         return;
  2332.     }
  2333.     /* Now loop forever, processing queries */
  2334.     for(;;){
  2335.         fromlen = sizeof(from);
  2336.     if((foo = recv_mbuf(Dsocket,&bp,0,(char *)&from,&fromlen)) == -1)
  2337.         break;  /* Server closing */
  2338.         if(foo == 0)
  2339.             continue;
  2340.         dhdr = mallocw(sizeof(struct dhdr));
  2341.         ntohdomain(dhdr,&bp);
  2342.     if(Dtrace) {
  2343.         tprintf("DNS: %u bytes from %s\n",foo,
  2344.         psocket((struct sockaddr *)&from));
  2345.         dumpdomain(dhdr,0);
  2346.     }
  2347.     /* Process queries only */
  2348.     if(dhdr->qr == QUERY) {
  2349.         /* Queries from ourself will cause a loop ! */
  2350.         if(ismyaddr(from.sin_addr.s_addr) != NULLIF) {
  2351.         if(Dtrace)
  2352.             tputs("DNS: question from myself ignored\n");
  2353.         free_dhdr(dhdr);
  2354.         continue;
  2355.         } else {
  2356.         dp=(struct dserver *)callocw(1,sizeof(struct dserver));
  2357.         dp->address = from.sin_addr.s_addr;
  2358.         dp->srtt = (Dserver_maxwait * 1000L) / MSPTICK;
  2359.         dp->timeout = dp->srtt * 2;
  2360.         dp->port = from.sin_port;
  2361.         if(dhdr->opcode == ZONEINIT) {
  2362.             /* ZONEINIT not implemented */
  2363.             free_dhdr(dhdr);
  2364.             free(dp);
  2365.          } else
  2366.             newproc("Domain server",1024,proc_query
  2367.                 ,0,(void *)dp,(void *)dhdr,0);
  2368.             }
  2369.         }
  2370.     }
  2371. }
  2372.                 
  2373. static int
  2374. dodnsserver(argc,argv,p)
  2375. int argc;
  2376. char *argv[];
  2377. void *p;
  2378. {
  2379.     struct DOM_FILE *t_dom_file;
  2380.     FILE *fp, *bfp;
  2381.     char *t, *t1, *t2,*t3, *t4;
  2382.     int done;
  2383.     int32 source;
  2384.     struct rr *frrp, *oldrrp;
  2385. #if    0
  2386.     struct soa *soap;
  2387. #endif
  2388.     char type, *delim = " \t";
  2389.     if(Drx == NULLPROC)
  2390.         {
  2391.         /* Get rid of any old data */
  2392.         t_dom_file = dom_file;
  2393.         while (t_dom_file)
  2394.             {
  2395.             free(t_dom_file->filename);
  2396.             free(t_dom_file->domain);
  2397.             free(t_dom_file);
  2398.             t_dom_file = t_dom_file->next;
  2399.             }
  2400.         dom_file = NULL;
  2401.         /*
  2402.         Find out where we're primary for (if anywhere)
  2403.         */
  2404.         t = mallocw(200);
  2405.         t2 = mallocw(200);
  2406.         t4 = mallocw(13);
  2407.         bfp = fopen(Dboot, READ_TEXT);
  2408.         if (bfp)
  2409.             while (1)
  2410.                 {
  2411.                 if (feof(bfp) || !fgets(t, 199, bfp))
  2412.                     {
  2413.                     fclose(bfp);
  2414.                     break;
  2415.                     }
  2416.                 t1 = strtok(t, delim);
  2417.                 if (!t1)
  2418.                     continue;
  2419.                 source = 0;
  2420.                 type = '0';
  2421.                 if (stricmp(t1, "primary") == 0)
  2422.                     type = '1';
  2423.                 if (stricmp(t1, "secondary") == 0)
  2424.                     type = '2';
  2425.                 if (type == '0')
  2426.                     continue;
  2427.                 t1 = strtok(NULL, delim);
  2428.                 if (!t1)
  2429.                     continue;
  2430.                 strlwr(t1);
  2431.                 strcpy(t2, t1);
  2432.                 t1 = strtok(NULL, delim);
  2433.                 if (!t1)
  2434.                     continue;
  2435.                 if (type == '2')
  2436.                     {
  2437.                     source = resolve(t1);
  2438.                     t1 = strtok(NULL, delim);
  2439.                     if (!t1)
  2440.                         continue;
  2441.                     }
  2442.                 rip(t1);
  2443.                 strcpy(t4, t1);
  2444.                 sprintf(t, "%s/%s", Dzones, t1);
  2445.                 t3 = t - 1;
  2446.                 while (*++t3)
  2447.                     if (*t3 == '\\')
  2448.                         *t3 = '/';
  2449.                 if (Dtrace)
  2450.                     tprintf("DNS: Looking for SOA record in %s\n", t);
  2451.                 fp = fopen(t, READ_TEXT);
  2452.                 if (fp)
  2453.                     {
  2454.                     done = 0;
  2455.                     oldrrp = NULLRR;
  2456.                     while(done == 0
  2457.                         && (frrp = get_rr(fp,oldrrp)) != NULLRR)
  2458.                         {
  2459.                         oldrrp = frrp;
  2460.                         if (frrp->type == TYPE_SOA)
  2461.                             {
  2462.                             done = 1;
  2463.                             if (dom_file == NULL)
  2464.                                 {
  2465.                                 dom_file = mallocw(sizeof(struct DOM_FILE));
  2466.                                 dom_file->next = NULL;
  2467.                                 }
  2468.                             else {
  2469.                                 t_dom_file = mallocw(sizeof(struct DOM_FILE));
  2470.                                 t_dom_file->next = dom_file;
  2471.                                 dom_file = t_dom_file;
  2472.                                 }
  2473.                             dom_file->filename = mallocw(13);
  2474.                             strcpy(dom_file->filename, t4);
  2475.                             dom_file->domain = mallocw(strlen(t2) + 2);
  2476.                             sprintf(dom_file->domain, "%s.", t2);
  2477.                             dom_file->dom_soa = frrp->rdata.soa;
  2478.                             dom_file->type = type;
  2479.                             dom_file->source = source;
  2480.                             if (Dtrace)
  2481.                                 {
  2482.                                 tprintf(" filename %s\n", dom_file->filename);
  2483.                                 tprintf(" mname %s\n", dom_file->dom_soa.mname);
  2484.                                 tprintf(" rname %s\n", dom_file->dom_soa.rname);
  2485.                                 tprintf(" serial %lu\n", dom_file->dom_soa.serial);
  2486.                                 tprintf(" refresh %lu\n", dom_file->dom_soa.refresh);
  2487.                                 tprintf(" retry %lu\n", dom_file->dom_soa.retry);
  2488.                                 tprintf(" expire %lu\n", dom_file->dom_soa.expire);
  2489.                                 tprintf(" minimum %lu\n", dom_file->dom_soa.minimum);
  2490.                                 }
  2491.                             }
  2492.                         }
  2493.                     fclose(fp);
  2494.                     }
  2495.                 else tprintf("failed to open\n");
  2496.                 }
  2497.     /* Start domain server task */
  2498.         free(t4);
  2499.         free(t2);
  2500.         free(t);
  2501.     Drx = newproc("Domain listener",1024,drx,0,NULL,NULL,0);
  2502.         }
  2503.     else tputs("DNS already running\n");
  2504.     return 0;
  2505. }
  2506.  
  2507. static int
  2508. dostopdnsserver(argc,argv,p)
  2509. int argc;
  2510. char *argv[];
  2511. void *p;
  2512. {
  2513.     if(Drx == NULLPROC)
  2514.     /* Start domain server task */
  2515.     tprintf("DNS not running\n");
  2516.     killproc(Drx);
  2517.     Drx = NULLPROC;
  2518.     return 0;
  2519. }
  2520.  
  2521. /* Free a domain message */
  2522. static void
  2523. free_dhdr(dp)
  2524. struct dhdr *dp;
  2525. {
  2526.     if(dp->qdcount != 0)
  2527.     free_rr(dp->questions);
  2528.     if(dp->ancount != 0)
  2529.     free_rr(dp->answers);
  2530.     if(dp->nscount != 0)
  2531.     free_rr(dp->authority);
  2532.     if(dp->arcount != 0)
  2533.     free_rr(dp->additional);
  2534.     free((char *)dp);
  2535. }
  2536.  
  2537. #endif
  2538.